home *** CD-ROM | disk | FTP | other *** search
/ Sprite 1984 - 1993 / Sprite 1984 - 1993.iso / src / lib / c / stdio / RCS / vfprintf.c,v < prev    next >
Encoding:
Text File  |  1992-03-27  |  32.8 KB  |  1,637 lines
  1. head     1.20;
  2. branch   ;
  3. access   ;
  4. symbols  sprited:1.20.1;
  5. locks    ; strict;
  6. comment  @ * @;
  7.  
  8.  
  9. 1.20
  10. date     91.08.27.17.35.55;  author rab;  state Exp;
  11. branches 1.20.1.1;
  12. next     1.19;
  13.  
  14. 1.19
  15. date     90.10.16.16.41.36;  author shirriff;  state Exp;
  16. branches ;
  17. next     1.18;
  18.  
  19. 1.18
  20. date     90.10.11.15.14.09;  author shirriff;  state Exp;
  21. branches ;
  22. next     1.17;
  23.  
  24. 1.17
  25. date     90.10.08.17.04.52;  author shirriff;  state Exp;
  26. branches ;
  27. next     1.16;
  28.  
  29. 1.16
  30. date     90.09.11.14.27.14;  author kupfer;  state Exp;
  31. branches ;
  32. next     1.15;
  33.  
  34. 1.15
  35. date     90.09.05.22.41.07;  author shirriff;  state Exp;
  36. branches ;
  37. next     1.14;
  38.  
  39. 1.14
  40. date     90.08.03.16.30.43;  author shirriff;  state Exp;
  41. branches ;
  42. next     1.13;
  43.  
  44. 1.13
  45. date     89.09.12.11.42.15;  author douglis;  state Exp;
  46. branches ;
  47. next     1.12;
  48.  
  49. 1.12
  50. date     89.08.04.16.05.13;  author douglis;  state Exp;
  51. branches ;
  52. next     1.11;
  53.  
  54. 1.11
  55. date     89.08.04.14.45.55;  author douglis;  state Exp;
  56. branches ;
  57. next     1.10;
  58.  
  59. 1.10
  60. date     89.07.28.15.57.35;  author douglis;  state Exp;
  61. branches ;
  62. next     1.9;
  63.  
  64. 1.9
  65. date     89.07.28.15.56.48;  author rab;  state Exp;
  66. branches ;
  67. next     1.8;
  68.  
  69. 1.8
  70. date     89.06.16.14.14.45;  author ouster;  state Exp;
  71. branches ;
  72. next     1.7;
  73.  
  74. 1.7
  75. date     89.05.25.05.50.03;  author rab;  state Exp;
  76. branches ;
  77. next     1.6;
  78.  
  79. 1.6
  80. date     89.05.17.14.32.46;  author rab;  state Exp;
  81. branches ;
  82. next     1.5;
  83.  
  84. 1.5
  85. date     88.10.23.15.39.51;  author ouster;  state Exp;
  86. branches ;
  87. next     1.4;
  88.  
  89. 1.4
  90. date     88.07.25.13.12.35;  author ouster;  state Exp;
  91. branches ;
  92. next     1.3;
  93.  
  94. 1.3
  95. date     88.07.21.09.36.16;  author ouster;  state Exp;
  96. branches ;
  97. next     1.2;
  98.  
  99. 1.2
  100. date     88.06.17.17.42.51;  author ouster;  state Exp;
  101. branches ;
  102. next     1.1;
  103.  
  104. 1.1
  105. date     88.06.10.16.23.36;  author ouster;  state Exp;
  106. branches ;
  107. next     ;
  108.  
  109. 1.20.1.1
  110. date     91.12.02.20.04.36;  author kupfer;  state Exp;
  111. branches ;
  112. next     ;
  113.  
  114.  
  115. desc
  116. @@
  117.  
  118.  
  119. 1.20
  120. log
  121. @Added a forward declaration for signbit.
  122. @
  123. text
  124. @/* 
  125.  * vfprintf.c --
  126.  *
  127.  *    Source code for the "vfprintf" library procedure.
  128.  *
  129.  * Copyright 1988 Regents of the University of California
  130.  * Permission to use, copy, modify, and distribute this
  131.  * software and its documentation for any purpose and without
  132.  * fee is hereby granted, provided that the above copyright
  133.  * notice appear in all copies.  The University of California
  134.  * makes no representations about the suitability of this
  135.  * software for any purpose.  It is provided "as is" without
  136.  * express or implied warranty.
  137.  */
  138.  
  139. #ifndef lint
  140. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.19 90/10/16 16:41:36 shirriff Exp Locker: rab $ SPRITE (Berkeley)";
  141. #endif not lint
  142.  
  143. #include <ctype.h>
  144. #include <stdio.h>
  145. #include <stdlib.h>
  146. #include <string.h>
  147. #include <varargs.h>
  148. #include <math.h>
  149.  
  150. extern int signbit _ARGS_ ((int value));
  151.  
  152. #ifndef TRUE
  153. #define TRUE 1
  154. #endif
  155. #ifndef FALSE
  156. #define FALSE 0
  157. #endif
  158.  
  159. /*
  160.  * The following defines the size of buffer needed to hold the ASCII
  161.  * digits for the largest floating-point number and the largest integer.
  162.  */
  163.  
  164. #define CVT_DBL_BUF_SIZE 320
  165. #define CVT_INT_BUF_SIZE 33
  166.  
  167. /*
  168.  *----------------------------------------------------------------------
  169.  *
  170.  * CvtUtoA --
  171.  *
  172.  *    Convert a number from internal form to a sequence of
  173.  *    ASCII digits.
  174.  *
  175.  * Results:
  176.  *    The return value is a pointer to the ASCII digits representing
  177.  *    i, and *lengthPtr will be filled in with the number of digits
  178.  *    stored at the location pointed to by the return value.  The
  179.  *    return value points somewhere inside buf, but not necessarily
  180.  *    to the beginning.  Note:  the digits are left null-terminated.
  181.  *
  182.  * Side effects:
  183.  *    None.
  184.  *
  185.  *----------------------------------------------------------------------
  186.  */
  187.  
  188. static char *
  189. CvtUtoA(i, base, buf, lengthPtr, capsFlag)
  190.     register unsigned i;    /* Value to convert. */
  191.     register int base;        /* Base for conversion.  Shouldn't be
  192.                  * larger than 36.  2, 8, and 16
  193.                  * execute fastest.
  194.                  */
  195.     register char *buf;        /* Buffer to use to hold converted string.
  196.                  * Must hold at least CVT_INT_BUF_SIZE bytes. */
  197.     int *lengthPtr;        /* Number of digits is stored here. */
  198.     int capsFlag;        /* 1 if want capital abcd... */
  199. {
  200.     register char *p;
  201.     register char hexOffset = (capsFlag ? 'A': 'a')-'9'-1;
  202.  
  203.     /*
  204.      * Handle a zero value specially.
  205.      */
  206.  
  207.     if (i == 0) {
  208.     buf[0] = '0';
  209.     buf[1] = 0;
  210.     *lengthPtr = 1;
  211.     return buf;
  212.     }
  213.  
  214.     /*
  215.      * Build the string backwards from the end of the result array.
  216.      */
  217.  
  218.     p = &buf[CVT_INT_BUF_SIZE-1];
  219.     *p = 0;
  220.  
  221.     switch (base) {
  222.  
  223.     case 2:
  224.         while (i != 0) {
  225.         p -= 1;
  226.         *p = '0' + (i & 01);
  227.         i >>= 1;
  228.         }
  229.         break;
  230.     
  231.     case 8:
  232.         while (i != 0) {
  233.         p -= 1;
  234.         *p = '0' + (i & 07);
  235.         i >>= 3;
  236.         }
  237.         break;
  238.     
  239.     case 16:
  240.         while (i !=0) {
  241.         p -= 1;
  242.         *p = '0' + (i & 0xf);
  243.         if (*p > '9') {
  244.             *p += hexOffset;
  245.         }
  246.         i >>= 4;
  247.         }
  248.         break;
  249.     
  250.     default:
  251.         while (i != 0) {
  252.         p -= 1;
  253.         *p = '0' + (i % base);
  254.         if (*p > '9') {
  255.             *p += hexOffset;
  256.         }
  257.         i /= base;
  258.         }
  259.         break;
  260.     }
  261.  
  262.     *lengthPtr = (&buf[CVT_INT_BUF_SIZE-1] - p);
  263.     return p;
  264. }
  265.  
  266. /*
  267.  *----------------------------------------------------------------------
  268.  *
  269.  * CvtFtoA --
  270.  *
  271.  *    This procedure converts a double-precision floating-point
  272.  *    number to a string of ASCII digits.
  273.  *
  274.  * Results:
  275.  *    The characters at buf are modified to hold up to numDigits ASCII
  276.  *    characters, followed by a null character.  The digits represent
  277.  *    the most significant numDigits digits of value, with the lowest
  278.  *    digit rounded.  The value at *pointPtr is modified to hold
  279.  *    the number of characters in buf that precede the decimal point.
  280.  *    A negative value of *pointPtr means zeroes must be inserted
  281.  *    between the point and buf[0].  If value is negative, *signPtr
  282.  *    is set to TRUE;    otherwise it is set to FALSE.  The return value
  283.  *    is the number of digits stored in buf, which is either:
  284.  *    (a) numDigits (if the number is so huge that all numDigits places are
  285.  *        used before getting to the right precision level, or if
  286.  *        afterPoint is -1)
  287.  *    (b) afterPoint + *pointPtr (the normal case if afterPoint isn't -1)
  288.  *    If there were no significant digits within the specified precision,
  289.  *    then *pointPtr gets set to -afterPoint and 0 is returned.
  290.  *
  291.  * Side effects:
  292.  *    None.
  293.  *
  294.  *----------------------------------------------------------------------
  295.  */
  296.  
  297. static int
  298. CvtFtoA(value, numDigits, afterPoint, pointPtr, signPtr, buf, fpError)
  299.     double value;        /* Value to be converted. */
  300.     int numDigits;        /* Maximum number of significant digits
  301.                  * to generate in result. */
  302.     int afterPoint;        /* Maximum number of digits to generate
  303.                  * after the decimal point.  If -1, then
  304.                  * there there is no limit. */
  305.     int *pointPtr;        /* Will be filled in with position of
  306.                  * decimal point (number of digits before
  307.                  * decimal point). */
  308.     int *signPtr;        /* Modified to indicate whether or not
  309.                  * value was negative. */
  310.     char *buf;            /* Place to store ASCII digits.  Must hold
  311.                  * at least numDigits+1 bytes. */
  312.     int *fpError;               /* pointer to flag that is set if the number
  313.                                    is not a valid number. */
  314.  
  315. {
  316.     register char *p;
  317.     double fraction, intPart;
  318.     int i, numDigits2;
  319.     char tmpBuf[CVT_DBL_BUF_SIZE];
  320.                 /* Large enough to hold largest possible
  321.                  * floating-point number.
  322.                  */
  323.  
  324.     /*
  325.      * Take care of the sign.
  326.      */
  327.  
  328.     if (signbit(value)) {
  329.     *signPtr = TRUE;
  330.     value = -value;
  331.     } else {
  332.     *signPtr = FALSE;
  333.     }
  334.  
  335.     /*
  336.      * Make sure the value is a valid number
  337.      */
  338.     if (isinf(value)) {
  339.     /*
  340.      * Set the error flag so the invoking function will know
  341.      * that something is wrong.
  342.      */
  343.     *fpError = TRUE;
  344.     strcpy(buf, "Inf");
  345.     return sizeof("Inf") - 1;
  346.     }
  347.     if (isnan(value)) {
  348.     *fpError = TRUE;
  349.     strcpy(buf, "NaN");
  350.     return sizeof("NaN") - 1;
  351.     }
  352.  
  353.     *fpError = FALSE;
  354.  
  355.     /*
  356.      * Divide value into an integer and a fractional component.  Convert
  357.      * the integer to ASCII in a temporary buffer, then move the characters
  358.      * to the real buffer (since we're converting from the bottom up,
  359.      * we won't know the highest-order digit until last).
  360.      */
  361.  
  362.     fraction = modf(value, &intPart);
  363.     *pointPtr = 0;
  364.     for (p = &tmpBuf[CVT_DBL_BUF_SIZE-1]; intPart != 0; p -= 1) {
  365.     double tmp;
  366.     char digit;
  367.  
  368.     tmp = modf(intPart/10.0, &intPart);
  369.  
  370.     digit = (tmp * 10.0) + .2;
  371.     *p = digit + '0';
  372.     *pointPtr += 1;
  373.     }
  374.     p++;
  375.     for (i = 0; (i <= numDigits) && (p <= &tmpBuf[CVT_DBL_BUF_SIZE-1]);
  376.         i++, p++) {
  377.     buf[i] = *p;
  378.     }
  379.  
  380.     /*
  381.      * If the value was zero, put an initial zero in the buffer
  382.      * before the decimal point.
  383.      */
  384.     
  385.     if (value == 0.0) {
  386.     buf[0] = '0';
  387.     i = 1;
  388.     *pointPtr = 1;
  389.     }
  390.  
  391.     /*
  392.      * Now handle the fractional part that's left.  Repeatedly multiply
  393.      * by 10 to get the next digit.  At the beginning, the value may be
  394.      * very small, so do repeated multiplications until we get to a
  395.      * significant digit.
  396.      */
  397.     
  398.     if ((i == 0) && (fraction > 0)) {
  399.     while (fraction < .1) {
  400.         fraction *= 10.0;
  401.         *pointPtr -= 1;
  402.     };
  403.     }
  404.  
  405.     /*
  406.      * Compute how many total digits we should generate, taking into
  407.      * account both numDigits and afterPoint.  Then generate the digits.
  408.      */
  409.     
  410.     numDigits2 = afterPoint + *pointPtr;
  411.     if ((afterPoint < 0) || (numDigits2 > numDigits)) {
  412.     numDigits2 = numDigits;
  413.     }
  414.     
  415.     for ( ; i <= numDigits2; i++) {
  416.     double tmp;
  417.     char digit;
  418.  
  419.     fraction = modf(fraction*10.0, &tmp);
  420.  
  421.     digit = tmp;
  422.     buf[i] = digit + '0';
  423.     }
  424.  
  425.     /*
  426.      * The code above actually computed one more digit than is really
  427.      * needed.  Use it to round the low-order significant digit, if
  428.      * necessary.  This could cause rounding to propagate all the way
  429.      * back through the number.
  430.      */
  431.     
  432.     if ((numDigits2 >= 0) && (buf[numDigits2] >= '5')) {
  433.     for (i = numDigits2-1; ; i--) {
  434.         if (i < 0) {
  435.         int j;
  436.  
  437.         /*
  438.          * Must slide the entire buffer down one slot to make
  439.          * room for a leading 1 in the buffer.  Careful: if we've
  440.          * already got numDigits digits, must drop the last one to
  441.          * add the 1.
  442.          */
  443.  
  444.         for (j = numDigits2; j > 0; j--) {
  445.             buf[j] = buf[j-1];
  446.         }
  447.         if (numDigits2 < numDigits) {
  448.             numDigits2++;
  449.         }
  450.         (*pointPtr)++;
  451.         buf[0] = '1';
  452.         break;
  453.         }
  454.  
  455.         buf[i] += 1;
  456.         if (buf[i] <= '9') {
  457.         break;
  458.         }
  459.         buf[i] = '0';
  460.     }
  461.     }
  462.  
  463.     if (numDigits2 <= 0) {
  464.     numDigits2 = 0;
  465.     *pointPtr = -afterPoint;
  466.     }
  467.     buf[numDigits2] = 0;
  468.     return numDigits2;
  469. }
  470.  
  471. /*
  472.  *----------------------------------------------------------------------
  473.  *
  474.  * vfprintf --
  475.  *
  476.  *    This utility routine does all of the real work of printing
  477.  *    formatted information.  It is called by printf, fprintf,
  478.  *    sprintf, vprintf, and vsprintf.
  479.  *
  480.  * Results:
  481.  *    The return value is the total number of characters printed.
  482.  *
  483.  * Side effects:
  484.  *    Information is output on stream.  See the manual page entry
  485.  *    for printf for details.
  486.  *
  487.  *----------------------------------------------------------------------
  488.  */
  489.  
  490. int
  491. vfprintf(stream, format, args)
  492.     register FILE *stream;    /* Where to output formatted results. */
  493.     register char *format;    /* Contains literal text and format control
  494.                  * sequences indicating how args are to be
  495.                  * printed.  See the man page for details. */
  496.     va_list args;        /* Variable number of values to be formatted
  497.                  * and printed. */
  498. {
  499.     int leftAdjust;        /* TRUE means field should be left-adjusted. */
  500.     int minWidth;        /* Minimum width of field. */
  501.     int precision;        /* Precision for field (e.g. digits after
  502.                  * decimal, or string length). */
  503.     int altForm;        /* TRUE means value should be converted to
  504.                  * an alternate form (depends on type of
  505.                  * conversion). */
  506.     register char c;        /* Current character from format string.
  507.                  * Eventually it ends up holding the format
  508.                  * type (e.g. 'd' for decimal). */
  509.     char pad;            /* Pad character. */
  510.     char buf[CVT_DBL_BUF_SIZE+10];
  511.                 /* Buffer used to hold converted numbers
  512.                  * before outputting to stream.  Must be
  513.                  * large enough for floating-point number
  514.                  * plus sign plus "E+XXX + null" */
  515.     char expBuf[CVT_INT_BUF_SIZE];
  516.                 /* Buffer to use for converting exponents. */
  517.     char *signChar;        /* This is the "+" or " " for the sign pos.  */
  518.     char *prefix;        /* Holds non-numeric stuff that precedes
  519.                  * number, such as "-" or "0x".  This is
  520.                  * kept separate to be sure we add padding
  521.                  * zeroes AFTER the prefix. */
  522.     register char *field;    /* Pointer to converted field. */
  523.     int actualLength;        /* Actual length of converted field. */
  524.     int point;            /* Location of decimal point, for "f" and
  525.                  * "e" conversions. */
  526.     int zeroPad;        /* Zeros to pad number with. */
  527.     int sign;            /* Also used for "f" and "e" conversions. */
  528.     int i, tmp;
  529.     int charsPrinted = 0;    /* Total number of characters output. */
  530.     char *end;
  531.     int fpError = FALSE;
  532.  
  533.     /*
  534.      * The main loop is to scan through the characters in format.
  535.      * Anything but a '%' is output directly to stream.  A '%'
  536.      * signals the start of a format field;  the formatting information
  537.      * is parsed, the next value from args is formatted and printed,
  538.      * and the loop goes on.
  539.      */
  540.  
  541.     for (c = *format; c != 0; format++, c = *format) {
  542.  
  543.     if (c != '%') {
  544.         putc(c, stream);
  545.         charsPrinted += 1;
  546.         continue;
  547.     }
  548.  
  549.     /*
  550.      * Parse off the format control fields.
  551.      */
  552.  
  553.     leftAdjust    = FALSE;
  554.     pad        = ' ';
  555.     minWidth    = 0;
  556.     precision    = -1;
  557.     altForm        = FALSE;
  558.     signChar    = "";
  559.     prefix        = "";
  560.     actualLength    = 0;
  561.     zeroPad        = 0;
  562.  
  563.     format++;  
  564.     c = *format;
  565.     while (TRUE) {
  566.         if (c == '-') {
  567.         leftAdjust = TRUE;
  568.         } else if (c == '0') {
  569.         pad = '0';
  570.         } else if (c == '#') {
  571.         altForm = TRUE;
  572.         } else if (c == '+') {
  573.         signChar = "+";
  574.         } else if (c== ' ') {
  575.         if (!*signChar) {
  576.             signChar = " ";
  577.         }
  578.         } else {
  579.         break;
  580.         }
  581.         format++;
  582.         c = *format;
  583.     }
  584.     if (isdigit(c)) {
  585.         minWidth = strtoul(format, &end, 10);
  586.         format = end;
  587.         c = *format;
  588.     } else if (c == '*') {
  589.         minWidth = va_arg(args, int);
  590.         format++; 
  591.         c = *format;
  592.     }
  593.     if (c == '.') {
  594.         format++; 
  595.         c = *format;
  596.         precision = 0;
  597.     }
  598.     if (isdigit(c)) {
  599.         precision = strtoul(format, &end, 10);
  600.         format = end;
  601.         c = *format;
  602.     } else if (c == '*') {
  603.         precision = va_arg(args, int);
  604.         format++; 
  605.         c = *format;
  606.     }
  607.     if (c == 'l') {            /* Ignored for compatibility. */
  608.         format++; 
  609.         c = *format;
  610.     }
  611.     if (c == 'h') {            /* Ignored for compatibility. */
  612.         format++; 
  613.         c = *format;
  614.     }
  615.  
  616.     /*
  617.      * Take action based on the format type (which is now in c).
  618.      */
  619.  
  620.     field = buf;
  621.     switch (c) {
  622.  
  623.         case 'D':
  624.         case 'd':
  625.         case 'i':
  626.         i = va_arg(args, int);
  627.         if (i < 0) {
  628.             prefix = "-";
  629.             i = -i;
  630.             actualLength = 1;
  631.         } else {
  632.             prefix = signChar;
  633.             actualLength = *prefix ? 1 : 0;
  634.         }
  635.         field = CvtUtoA((unsigned) i, 10, buf, &tmp, 0);
  636.         if (tmp < precision) {
  637.             zeroPad = precision-tmp;
  638.         }
  639.         actualLength += tmp+zeroPad;
  640.         break;
  641.         
  642.         case 'O':
  643.         case 'o':
  644.         i = va_arg(args, int);
  645.         field = CvtUtoA((unsigned) i, 8, buf, &tmp, 0);
  646.         if (tmp < precision) {
  647.             zeroPad = precision-tmp;
  648.         }
  649.         if (altForm && (i != 0) && zeroPad==0) {
  650.             prefix = "0";
  651.             actualLength = 1;
  652.         }
  653.         actualLength += tmp+zeroPad;
  654.         break;
  655.         
  656.         case 'X':
  657.         case 'x':
  658.         case 'p':
  659.         i = va_arg(args, int);
  660.         field = CvtUtoA((unsigned) i, 16, buf, &actualLength, c=='X');
  661.         if (actualLength < precision) {
  662.             zeroPad = precision-actualLength;
  663.             actualLength += zeroPad;
  664.         }
  665.         if (altForm) {
  666.             char *p;
  667.             if (c == 'X') {
  668.             if (i != 0) {
  669.                 prefix = "0X";
  670.                 actualLength += 2;
  671.             }
  672.             for (p = field; *p != 0; p++) {
  673.                 if (*p >= 'a') {
  674.                 *p += 'A' - 'a';
  675.                 }
  676.             }
  677.             } else if (i != 0) {
  678.             prefix = "0x";
  679.             actualLength += 2;
  680.             }
  681.         }
  682.         break;
  683.         
  684.         case 'U':
  685.         case 'u':
  686.         field = CvtUtoA(va_arg(args, unsigned), 10, buf,
  687.             &actualLength, 0);
  688.         if (actualLength < precision) {
  689.             zeroPad = precision-actualLength;
  690.             actualLength += zeroPad;
  691.         }
  692.         break;
  693.         
  694.         case 's':
  695.         field = va_arg(args, char *);
  696.         if (field == (char *) NULL) {
  697.             field = "(NULL)";
  698.         } 
  699.         actualLength = strlen(field);
  700.         if ((precision >= 0) && (precision < actualLength)) {
  701.             actualLength = precision;
  702.         }
  703.         pad = ' ';
  704.         break;
  705.  
  706.         case 'c':
  707.         buf[0] = va_arg(args, int);
  708.         actualLength = 1;
  709.         pad = ' ';
  710.         break;
  711.  
  712.         case 'F':
  713.         case 'f':
  714.         if (precision < 0) {
  715.             precision = 6;
  716.         } else if (precision > CVT_DBL_BUF_SIZE) {
  717.             precision = CVT_DBL_BUF_SIZE;
  718.         }
  719.  
  720.         /*
  721.          * Just generate the digits and compute the total length
  722.          * here.  The rest of the work will be done when the
  723.          * characters are actually output, below.
  724.          */
  725. #ifdef sun4
  726.          /*
  727.           * Varargs is not correctly implemented in gcc version 1.34
  728.           * for the sun4.  This problem should be fixed in the next
  729.           * version of the compiler, and this code can then be
  730.           * deleted.
  731.           */
  732.          {
  733.              union {
  734.                  long i[2];
  735.                  double d;
  736.              } u;
  737.  
  738.              u.i[0] = va_arg(args, long);
  739.              u.i[1] = va_arg(args, long);
  740.  
  741.              actualLength = CvtFtoA(u.d, CVT_DBL_BUF_SIZE,
  742.              precision, &point, &sign, field, &fpError);
  743.          }
  744. #else
  745.         actualLength = CvtFtoA(va_arg(args, double), CVT_DBL_BUF_SIZE,
  746.             precision, &point, &sign, field, &fpError);
  747. #endif
  748.         if (sign) {
  749.             prefix = "-";
  750.             actualLength += 1;
  751.         } else {
  752.             prefix = signChar;
  753.             actualLength += *prefix ? 1 : 0;
  754.         }
  755.         if (fpError) {
  756.             pad = ' ';
  757.             break;
  758.         }
  759.         if (point <= 0) {
  760.             actualLength += 1 - point;
  761.         }
  762.         if ((precision != 0) || (altForm)) {
  763.             actualLength += 1;
  764.         }
  765.         c = 'f';
  766.         break;
  767.  
  768.         case 'E':
  769.         case 'e':
  770.         if (precision < 0) {
  771.             precision = 6;
  772.         } else if (precision > CVT_DBL_BUF_SIZE-1) {
  773.             precision = CVT_DBL_BUF_SIZE-1;
  774.         }
  775. #ifdef sun4
  776.          /*
  777.           * Varargs is not correctly implemented in gcc version 1.34
  778.           * for the sun4.  This problem should be fixed in the next
  779.           * version of the compiler, and this code can then be
  780.           * deleted.
  781.           */
  782.          {
  783.              union {
  784.                  long i[2];
  785.                  double d;
  786.              } u;
  787.  
  788.              u.i[0] = va_arg(args, long);
  789.              u.i[1] = va_arg(args, long);
  790.  
  791.              actualLength = CvtFtoA(u.d, precision+1, -1,
  792.              &point, &sign, &buf[1], &fpError);
  793.          }
  794. #else
  795.         actualLength = CvtFtoA(va_arg(args, double), precision+1, -1,
  796.             &point, &sign, &buf[1], &fpError);
  797. #endif
  798.         if (fpError) {
  799.             pad = ' ';
  800.             field = &buf[1];
  801.             if (sign) {
  802.             prefix = "-";
  803.             actualLength += 1;
  804.             } else {
  805.             prefix = signChar;
  806.             actualLength += *prefix ? 1 : 0;
  807.             }
  808.             break;
  809.         }
  810.         eFromG:
  811.  
  812.         /*
  813.          * Insert a decimal point after the first digit of the number.
  814.          * If no digits after decimal point, then don't print decimal
  815.          * unless in altForm.
  816.          */
  817.  
  818.         buf[0] = buf[1];
  819.         buf[1] = '.';
  820.         if ((precision != 0) || (altForm)) {
  821.             field = buf + precision + 2;
  822.         } else {
  823.             field = &buf[1];
  824.         }
  825.  
  826.         /*
  827.          * Convert the exponent.
  828.          */
  829.         
  830.         *field = c;
  831.             field++;
  832.         point--;    /* One digit before decimal point. */
  833.         if (point < 0) {
  834.             *field = '-';
  835.             point = -point;
  836.         } else {
  837.             *field = '+';
  838.         }
  839.         field++;
  840.         if (point < 10) {
  841.             *field = '0';
  842.             field++;
  843.         }
  844.         strcpy(field, CvtUtoA((unsigned) point, 10, expBuf, &i, 0));
  845.         actualLength = (field - buf) + i;
  846.         field = buf;
  847.         if (sign) {
  848.             prefix = "-";
  849.             actualLength += 1;
  850.         } else {
  851.             prefix = signChar;
  852.             actualLength += *prefix ? 1 : 0;
  853.         }
  854.         break;
  855.  
  856.         case 'G':
  857.         case 'g': {
  858.         int eLength, fLength;
  859.  
  860.         if (precision < 0) {
  861.             precision = 6;
  862.         } else if (precision > CVT_DBL_BUF_SIZE-1) {
  863.             precision = CVT_DBL_BUF_SIZE-1;
  864.         } else if (precision == 0) {
  865.             precision = 1;
  866.         }
  867.  
  868. #ifdef sun4
  869.          /*
  870.           * Varargs is not correctly implemented in gcc version 1.34
  871.           * for the sun4.  This problem should be fixed in the next
  872.           * version of the compiler, and this code can then be
  873.           * deleted.
  874.           */
  875.          {
  876.              union {
  877.                  long i[2];
  878.                  double d;
  879.              } u;
  880.  
  881.              u.i[0] = va_arg(args, long);
  882.              u.i[1] = va_arg(args, long);
  883.  
  884.              actualLength = CvtFtoA(u.d, precision,
  885.              -1, &point, &sign, &buf[1], &fpError);
  886.          }
  887. #else
  888.         actualLength = CvtFtoA(va_arg(args, double), precision,
  889.             -1, &point, &sign, &buf[1], &fpError);
  890.  
  891. #endif
  892.         if (fpError) {
  893.             pad = ' ';
  894.             field = &buf[1];
  895.             if (sign) {
  896.             prefix = "-";
  897.             actualLength += 1;
  898.             } else {
  899.             prefix = signChar;
  900.             actualLength += *prefix ? 1 : 0;
  901.             }
  902.             break;
  903.         }
  904.         if (!altForm) {
  905.             for ( ; actualLength > 1; actualLength--) {
  906.             if (buf[actualLength] != '0') {
  907.                 break;
  908.             }
  909.             }
  910.         }
  911.         if ((actualLength > 1) || altForm) {
  912.             eLength = actualLength + 5;
  913.         } else {
  914.             eLength = actualLength + 4;
  915.         }
  916.         if (point <= 0) {
  917.             fLength = actualLength + 2 - point;
  918.         } else {
  919.             fLength = actualLength;
  920.             if (point < actualLength) {
  921.             fLength += 1;
  922.             } else if (altForm) {
  923.             fLength = point + 1;
  924.             } else {
  925.             fLength = point;
  926.             }
  927.         }
  928.  
  929.         /*
  930.          * Use "e" format if it results in fewer digits than "f"
  931.          * format, or if it would result in non-significant zeroes
  932.          * being printed.  Remember that precision means something
  933.          * different in "e" and "f" (digits after decimal) than it
  934.          * does in "g" (significant digits).
  935.          */
  936.  
  937.         if ((eLength < fLength) || (point > precision)) {
  938.             c += 'E' - 'G';
  939.             precision = actualLength-1;
  940.             goto eFromG;
  941.         }
  942.         c = 'f';
  943.         field = &buf[1];
  944.         actualLength = fLength;
  945.         if (sign) {
  946.             prefix = "-";
  947.             actualLength += 1;
  948.         } else {
  949.             prefix = signChar;
  950.             actualLength += *prefix ? 1 : 0;
  951.         }
  952.         break;
  953.         }
  954.  
  955.         case '%':
  956.         putc('%', stream);
  957.         charsPrinted += 1;
  958.         goto endOfField;
  959.  
  960.         case 0:
  961.         return charsPrinted;
  962.  
  963.         default:
  964.         putc(c, stream);
  965.         charsPrinted += 1;
  966.         goto endOfField;
  967.     }
  968.  
  969.     /*
  970.      * Things get tricky if we want to pad with 0's and left justify.
  971.      */
  972.     if (leftAdjust && pad == '0') {
  973.         if (c=='f' || c=='F' || c=='e' || c=='E' || c=='g' || c=='G') {
  974.         pad = ' ';
  975.         } else {
  976.         leftAdjust = FALSE;
  977.         }
  978.     }
  979.  
  980.     /* Handle pad characters on the left.  If the pad is '0', then
  981.      * padding goes after the prefix.  Otherwise, padding goes before
  982.      * the prefix.
  983.      */
  984.  
  985.     if (!leftAdjust) {
  986.         if (pad == '0') {
  987.         for ( ; *prefix != 0; prefix++) {
  988.             putc(*prefix, stream);
  989.             charsPrinted += 1;
  990.             actualLength--;
  991.             minWidth--;
  992.         }
  993.         }
  994.         while (minWidth > actualLength) {
  995.         putc(pad, stream);
  996.         charsPrinted += 1;
  997.         minWidth --;
  998.         }
  999.     }
  1000.  
  1001.     /*
  1002.      * Output anything left in the prefix.
  1003.      */
  1004.  
  1005.     minWidth -= actualLength;
  1006.     for ( ; *prefix != 0; prefix++) {
  1007.         putc(*prefix, stream);
  1008.         charsPrinted += 1;
  1009.         actualLength--;
  1010.     }
  1011.  
  1012.     /*
  1013.      * Pad the digits to the right length with 0's.
  1014.      */
  1015.     for (; zeroPad>0; zeroPad--) {
  1016.         putc('0', stream);
  1017.         charsPrinted += 1;
  1018.         actualLength--;
  1019.     }
  1020.  
  1021.     /*
  1022.      * "F" and "f" formats are handled specially here:  output
  1023.      * everything up to and including the decimal point.
  1024.      */
  1025.  
  1026.     if (c == 'f' && !fpError) {
  1027.         if (point <= 0) {
  1028.         if (actualLength > 0) {
  1029.             putc('0', stream);
  1030.             charsPrinted += 1;
  1031.             point++;
  1032.             actualLength--;
  1033.         }
  1034.         if (actualLength > 0) {
  1035.             charsPrinted += 1;
  1036.             putc('.', stream);
  1037.             actualLength--;
  1038.         }
  1039.         while ((point <= 0) && (actualLength > 0)) {
  1040.             putc('0', stream);
  1041.             charsPrinted += 1;
  1042.             point++;
  1043.             actualLength--;
  1044.         }
  1045.         } else {
  1046.         while ((point > 0) && (actualLength > 0)) {
  1047.             putc(*field, stream);
  1048.             charsPrinted += 1;
  1049.             field++;
  1050.             point--;
  1051.             actualLength--;
  1052.         }
  1053.         if (actualLength > 0) {
  1054.             putc('.', stream);
  1055.             charsPrinted += 1;
  1056.             actualLength--;
  1057.         }
  1058.         }
  1059.     }
  1060.  
  1061.     /*
  1062.      * Output the contents of the field (for "f" format, this is
  1063.      * just the stuff after the decimal point).
  1064.      */
  1065.  
  1066.     charsPrinted += actualLength;
  1067.     for ( ; actualLength > 0; actualLength--, field++) {
  1068.         putc(*field, stream);
  1069.         }
  1070.  
  1071.     /*
  1072.      * Pad the right of the field, if necessary.
  1073.      */
  1074.  
  1075.     while (minWidth > 0) {
  1076.         putc(' ', stream);
  1077.         charsPrinted += 1;
  1078.         minWidth --;
  1079.     }
  1080.  
  1081.     endOfField: continue;
  1082.     }
  1083.     return charsPrinted;
  1084. }
  1085. @
  1086.  
  1087.  
  1088. 1.20.1.1
  1089. log
  1090. @Initial branch for Sprite server.
  1091. @
  1092. text
  1093. @d17 1
  1094. a17 1
  1095. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.20 91/08/27 17:35:55 rab Exp Locker: rab $ SPRITE (Berkeley)";
  1096. @
  1097.  
  1098.  
  1099. 1.19
  1100. log
  1101. @Changed printf to print Inf, NaN, and to put signs on these.
  1102. @
  1103. text
  1104. @d17 1
  1105. a17 1
  1106. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.18 90/10/11 15:14:09 shirriff Exp Locker: shirriff $ SPRITE (Berkeley)";
  1107. d26 2
  1108. @
  1109.  
  1110.  
  1111. 1.18
  1112. log
  1113. @Modified left-adjust vs. 0 padding conflict to match ginger.
  1114. @
  1115. text
  1116. @d17 1
  1117. a17 1
  1118. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.17 90/10/08 17:04:52 shirriff Exp Locker: shirriff $ SPRITE (Berkeley)";
  1119. d200 11
  1120. d219 2
  1121. a220 2
  1122.     strcpy(buf, "(INFINITY)");
  1123.     return sizeof("(INFINITY)") - 1;
  1124. d224 2
  1125. a225 2
  1126.     strcpy(buf, "(NaN)");
  1127.     return sizeof("(NaN)") - 1;
  1128. d227 1
  1129. a230 11
  1130.      * Take care of the sign.
  1131.      */
  1132.  
  1133.     if (value < 0.0) {
  1134.     *signPtr = TRUE;
  1135.     value = -value;
  1136.     } else {
  1137.     *signPtr = FALSE;
  1138.     }
  1139.  
  1140.     /*
  1141. d623 7
  1142. a639 7
  1143.         if (sign) {
  1144.             prefix = "-";
  1145.             actualLength += 1;
  1146.         } else {
  1147.             prefix = signChar;
  1148.             actualLength += *prefix ? 1 : 0;
  1149.         }
  1150. d676 7
  1151. d770 7
  1152. @
  1153.  
  1154.  
  1155. 1.17
  1156. log
  1157. @Fix to handle (NaN) correctly.
  1158. @
  1159. text
  1160. @d17 1
  1161. a17 1
  1162. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.16 90/09/11 14:27:14 kupfer Exp Locker: shirriff $ SPRITE (Berkeley)";
  1163. d623 1
  1164. d673 1
  1165. d760 1
  1166. d830 1
  1167. a830 1
  1168.      * Don't left adjust if we're padding the number only with 0's.
  1169. d832 6
  1170. a837 2
  1171.     if (pad == '0') {
  1172.         leftAdjust = FALSE;
  1173. @
  1174.  
  1175.  
  1176. 1.16
  1177. log
  1178. @Use function prototypes. Lint.
  1179. @
  1180. text
  1181. @d17 1
  1182. a17 1
  1183. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.15 90/09/05 22:41:07 shirriff Exp Locker: kupfer $ SPRITE (Berkeley)";
  1184. d672 1
  1185. d758 1
  1186. @
  1187.  
  1188.  
  1189. 1.15
  1190. log
  1191. @Added 'h' flag.
  1192. Fixed a bug with the wrong variable name, that caused printed hex
  1193. numbers to disappear sometimes.
  1194. @
  1195. text
  1196. @d17 1
  1197. a17 1
  1198. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.14 90/08/03 16:30:43 shirriff Exp $ SPRITE (Berkeley)";
  1199. d25 1
  1200. a190 1
  1201.     extern double modf();
  1202. @
  1203.  
  1204.  
  1205. 1.14
  1206. log
  1207. @Fixed a bunch of bugs in printf.
  1208. @
  1209. text
  1210. @d17 1
  1211. a17 1
  1212. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.13 89/09/12 11:42:15 douglis Exp $ SPRITE (Berkeley)";
  1213. d485 4
  1214. d535 1
  1215. a535 1
  1216.         if (tmp < precision) {
  1217. @
  1218.  
  1219.  
  1220. 1.13
  1221. log
  1222. @use isinf and isnan functions.
  1223. @
  1224. text
  1225. @d17 1
  1226. a17 1
  1227. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.12 89/08/04 16:05:13 douglis Exp Locker: douglis $ SPRITE (Berkeley)";
  1228. d63 1
  1229. a63 1
  1230. CvtUtoA(i, base, buf, lengthPtr)
  1231. d72 1
  1232. d75 1
  1233. d118 1
  1234. a118 1
  1235.             *p += 'a' - '9' - 1;
  1236. d129 1
  1237. a129 1
  1238.             *p += 'a' - '9' - 1;
  1239. d391 1
  1240. d400 1
  1241. d432 1
  1242. d434 2
  1243. a435 1
  1244.     actualLength = 0;
  1245. d447 5
  1246. a451 2
  1247.         prefix = "+";
  1248.         actualLength = 1;
  1249. d470 1
  1250. d495 1
  1251. d501 3
  1252. d505 5
  1253. a509 2
  1254.         field = CvtUtoA((unsigned) i, 10, buf, &tmp);
  1255.         actualLength += tmp;
  1256. d515 5
  1257. a519 1
  1258.         if (altForm && (i != 0)) {
  1259. d523 1
  1260. a523 2
  1261.         field = CvtUtoA((unsigned) i, 8, buf, &tmp);
  1262.         actualLength += tmp;
  1263. d528 1
  1264. d530 5
  1265. a534 1
  1266.         field = CvtUtoA((unsigned) i, 16, buf, &actualLength);
  1267. d557 5
  1268. a561 1
  1269.             &actualLength);
  1270. d630 3
  1271. d704 1
  1272. a704 1
  1273.         strcpy(field, CvtUtoA((unsigned) point, 10, expBuf, &i));
  1274. d710 3
  1275. d799 3
  1276. d820 7
  1277. d855 9
  1278. @
  1279.  
  1280.  
  1281. 1.12
  1282. log
  1283. @more changes for omitted fpError arg.  (done by jhh)
  1284. @
  1285. text
  1286. @d17 1
  1287. a17 1
  1288. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.10 89/07/28 15:57:35 douglis Exp Locker: douglis $ SPRITE (Berkeley)";
  1289. a191 1
  1290.     int word;
  1291. d200 1
  1292. a200 6
  1293.     {
  1294.     union {
  1295.         double d;
  1296.         long l[2];
  1297.     } u;
  1298.  
  1299. d202 2
  1300. a203 1
  1301.      * Put the value into a union so we can check out the bits.
  1302. d205 8
  1303. a212 54
  1304.     u.d = value;
  1305.  
  1306.     /*
  1307.      * Set up the indexes into u.l based on machine type.
  1308.      */
  1309. #ifdef ds3100
  1310.     word = 1;
  1311. #else /* ds3100 */
  1312.     word = 0;
  1313. #endif /* ds3100 */    
  1314.     
  1315.  
  1316.     /*
  1317.      * An IEEE Std 754 double precision floating point number
  1318.          * has the following format:
  1319.      *
  1320.      *      1  bit       -- sign of Mantissa
  1321.      *      11 bits      -- exponent
  1322.      *      52 bits      -- Mantissa
  1323.      *
  1324.      * If the exponent has all bits set, the value is not a 
  1325.      * real number.
  1326.      *
  1327.      * If the Mantissa is zero then the value is infinity, which
  1328.      * is the result of division by zero, or overflow.
  1329.      *
  1330.      * If the Mantissa is non-zero the value is not a number (NaN).
  1331.      * NaN can be generated by dividing zero by itself, taking the
  1332.      * logarithm of a negative number, etc.
  1333.      */
  1334.  
  1335.     /*
  1336.      * check the exponent
  1337.      */
  1338.     if ((u.l[word] & 0x7ff00000) == 0x7ff00000) {
  1339.         /*
  1340.          * Set the error flag so the invoking function will know
  1341.          * that something is wrong.
  1342.          */
  1343.         *fpError = TRUE;
  1344.  
  1345.         /*
  1346.          * See if the Mantissa is zero.
  1347.          */
  1348.         if ((u.l[word] & ~0xfff00000) == 0 && u.l[word ? 0 : 1] == 0) {
  1349.         strcpy(buf, "(INFINITY)");
  1350.         return sizeof("(INFINITY)") - 1;
  1351.         } else {
  1352.         strcpy(buf, "(NaN)");
  1353.         return sizeof("(NaN)") - 1;
  1354.         }
  1355.     } else {
  1356.         *fpError = FALSE;
  1357.     }
  1358. d214 1
  1359. @
  1360.  
  1361.  
  1362. 1.11
  1363. log
  1364. @temp change for ds3100 floating
  1365. @
  1366. text
  1367. @d679 1
  1368. a679 1
  1369.              &point, &sign, &buf[1]);
  1370. d683 1
  1371. a683 1
  1372.             &point, &sign, &buf[1]);
  1373. d760 1
  1374. a760 1
  1375.              -1, &point, &sign, &buf[1], fpError);
  1376. @
  1377.  
  1378.  
  1379. 1.10
  1380. log
  1381. @fixed bug with omitted argument
  1382. @
  1383. text
  1384. @d17 1
  1385. a17 1
  1386. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.9 89/07/28 15:56:48 rab Exp Locker: douglis $ SPRITE (Berkeley)";
  1387. d192 1
  1388. d213 10
  1389. d244 1
  1390. a244 1
  1391.     if ((u.l[0] & 0x7ff00000) == 0x7ff00000) {
  1392. d254 1
  1393. a254 1
  1394.         if ((u.l[0] & ~0xfff00000) == 0 && u.l[1] == 0) {
  1395. @
  1396.  
  1397.  
  1398. 1.9
  1399. log
  1400. @ifdefs for sun4 for varargs (c.i. by FD)
  1401. @
  1402. text
  1403. @d17 1
  1404. a17 1
  1405. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.8 89/06/16 14:14:45 ouster Exp Locker: rab $ SPRITE (Berkeley)";
  1406. d749 1
  1407. a749 1
  1408.              -1, &point, &sign, &buf[1]);
  1409. d753 1
  1410. a753 1
  1411.             -1, &point, &sign, &buf[1]);
  1412. @
  1413.  
  1414.  
  1415. 1.8
  1416. log
  1417. @Zero-precision wasn't handled right for strings.
  1418. @
  1419. text
  1420. @d17 1
  1421. a17 1
  1422. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.7 89/05/25 05:50:03 rab Exp $ SPRITE (Berkeley)";
  1423. d605 15
  1424. d621 4
  1425. d627 1
  1426. d651 20
  1427. d673 1
  1428. d731 21
  1429. d754 2
  1430. @
  1431.  
  1432.  
  1433. 1.7
  1434. log
  1435. @Fixed CvtFtoA to properly handle infinity and NaN.
  1436. @
  1437. text
  1438. @d17 1
  1439. a17 1
  1440. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.6 89/05/17 14:32:46 rab Exp $ SPRITE (Berkeley)";
  1441. d580 1
  1442. a580 1
  1443.         if ((precision > 0) && (precision < actualLength)) {
  1444. @
  1445.  
  1446.  
  1447. 1.6
  1448. log
  1449. @Added `+' modifier to print out the sign.
  1450. @
  1451. text
  1452. @d17 1
  1453. a17 1
  1454. static char rcsid[] = "$Header: /sprite/src/lib/c/stdio/RCS/vfprintf.c,v 1.5 88/10/23 15:39:51 ouster Exp Locker: rab $ SPRITE (Berkeley)";
  1455. d170 1
  1456. a170 1
  1457. CvtFtoA(value, numDigits, afterPoint, pointPtr, signPtr, buf)
  1458. d184 3
  1459. a191 1
  1460.  
  1461. d196 59
  1462. a254 1
  1463.     
  1464. d440 1
  1465. d591 1
  1466. a591 1
  1467.         
  1468. d606 5
  1469. a610 2
  1470.         actualLength = CvtFtoA(va_arg(args, double),
  1471.             CVT_DBL_BUF_SIZE, precision, &point, &sign, field);
  1472. d631 1
  1473. a631 1
  1474.         (void) CvtFtoA(va_arg(args, double), precision+1, -1,
  1475. d633 3
  1476. a635 1
  1477.  
  1478. d643 1
  1479. a643 1
  1480.          
  1481. d678 1
  1482. a678 1
  1483.         
  1484. d692 3
  1485. d761 1
  1486. a761 1
  1487.     
  1488. d794 1
  1489. a794 1
  1490.     if (c == 'f') {
  1491. d842 1
  1492. a842 1
  1493.     
  1494. @
  1495.  
  1496.  
  1497. 1.5
  1498. log
  1499. @Change position of "#" in formats, permit flags in any order.
  1500. @
  1501. text
  1502. @d17 1
  1503. a17 1
  1504. static char rcsid[] = "$Header: vfprintf.c,v 1.4 88/07/25 13:12:35 ouster Exp $ SPRITE (Berkeley)";
  1505. d390 1
  1506. a390 1
  1507.     
  1508. d407 1
  1509. d418 3
  1510. a458 1
  1511.     actualLength = 0;
  1512. @
  1513.  
  1514.  
  1515. 1.4
  1516. log
  1517. @Lint.
  1518. @
  1519. text
  1520. @d17 1
  1521. a17 1
  1522. static char rcsid[] = "$Header: vfprintf.c,v 1.3 88/07/21 09:36:16 ouster Exp $ SPRITE (Berkeley)";
  1523. d410 11
  1524. a420 3
  1525.     if (c == '-') {
  1526.         leftAdjust = TRUE;
  1527.         format++; 
  1528. a421 5
  1529.     };
  1530.     while (c == '0') {
  1531.         pad = '0';
  1532.         format++; 
  1533.         c = *format;
  1534. a441 5
  1535.         format++; 
  1536.         c = *format;
  1537.     }
  1538.     if (c == '#') {
  1539.         altForm = TRUE;
  1540. @
  1541.  
  1542.  
  1543. 1.3
  1544. log
  1545. @Change from _doprnt to vfprintf.
  1546. @
  1547. text
  1548. @d17 1
  1549. a17 1
  1550. static char rcsid[] = "$Header: vfprintf.c,v 1.2 88/06/17 17:42:51 ouster Exp $ SPRITE (Berkeley)";
  1551. d20 5
  1552. a24 4
  1553. #include "ctype.h"
  1554. #include "stdio.h"
  1555. #include "string.h"
  1556. #include "varargs.h"
  1557. @
  1558.  
  1559.  
  1560. 1.2
  1561. log
  1562. @Accidentally used old Cvt_FtoA routine.
  1563. @
  1564. text
  1565. @d2 1
  1566. a2 1
  1567.  * _doprnt.c --
  1568. d4 1
  1569. a4 1
  1570.  *    Source code for the "_doprnt" library procedure.
  1571. d17 1
  1572. a17 1
  1573. static char rcsid[] = "$Header: _doprnt.c,v 1.1 88/06/10 16:23:36 ouster Exp $ SPRITE (Berkeley)";
  1574. d324 1
  1575. a324 1
  1576.  * _doprnt --
  1577. d327 2
  1578. a328 2
  1579.  *    formatted information.  It is called by printf, fprintf, and
  1580.  *    sprintf.
  1581. d341 2
  1582. a342 1
  1583. _doprnt(format, args, stream)
  1584. d346 1
  1585. a346 1
  1586.     va_list *args;        /* Variable number of values to be formatted
  1587. a347 1
  1588.     register FILE *stream;    /* Where to output formatted results. */
  1589. d424 1
  1590. a424 1
  1591.         minWidth = va_arg(*args, int);
  1592. d437 1
  1593. a437 1
  1594.         precision = va_arg(*args, int);
  1595. d461 1
  1596. a461 1
  1597.         i = va_arg(*args, int);
  1598. d473 1
  1599. a473 1
  1600.         i = va_arg(*args, int);
  1601. d484 1
  1602. a484 1
  1603.         i = va_arg(*args, int);
  1604. d507 1
  1605. a507 1
  1606.         field = CvtUtoA(va_arg(*args, unsigned), 10, buf,
  1607. d512 1
  1608. a512 1
  1609.         field = va_arg(*args, char *);
  1610. d524 1
  1611. a524 1
  1612.         buf[0] = va_arg(*args, int);
  1613. d543 1
  1614. a543 1
  1615.         actualLength = CvtFtoA(va_arg(*args, double),
  1616. d565 1
  1617. a565 1
  1618.         (void) CvtFtoA(va_arg(*args, double), precision+1, -1,
  1619. d622 1
  1620. a622 1
  1621.         actualLength = CvtFtoA(va_arg(*args, double), precision,
  1622. @
  1623.  
  1624.  
  1625. 1.1
  1626. log
  1627. @Initial revision
  1628. @
  1629. text
  1630. @d17 1
  1631. a17 1
  1632. static char rcsid[] = "$Header: atoi.c,v 1.1 88/04/28 17:20:23 ouster Exp $ SPRITE (Berkeley)";
  1633. d622 1
  1634. a622 1
  1635.         actualLength = Cvt_FtoA(va_arg(*args, double), precision,
  1636. @
  1637.